class SequentialTaskExecutor {
  constructor() {
    this.isPaused = false;
    this.isAborted = false;
    this.currentPromise = null;
  }

  /**
   * 暂停执行
   */
  pause() {
    this.isPaused = true;
  }

  /**
   * 终止执行
   */
  abort() {
    this.isPaused = true;
    this.isAborted = true;
  }

  /**
   * 检查是否可以继续执行
   * @returns {boolean} 是否可以继续执行
   */
  canContinue() {
    return !this.isPaused && !this.isAborted;
  }

  /**
   * 按顺序执行Promise任务队列
   * @param {Array<Function>} tasks - 任务数组，每个元素是返回Promise的函数
   * @param {Object} options - 配置选项
   * @param {boolean} options.stopOnError - 遇到错误是否停止执行，默认true
   * @param {Function} options.onTaskStart - 单个任务开始时的回调 (index, task) => {}
   * @param {Function} options.onTaskComplete - 单个任务完成时的回调 (index, result) => {}
   * @param {Function} options.onTaskError - 单个任务出错时的回调 (index, error) => {}
   * @returns {Promise<{results: Array, errors: Array, isAborted: boolean, isPaused: boolean, finalError?: Error}>} - 包含所有结果和状态的Promise
   */
  execute(tasks = [], options = {}) {
    // 重置状态
    this.isPaused = false;
    this.isAborted = false;

    // 默认配置
    const {
      stopOnError = true,
      onTaskStart = () => {},
      onTaskComplete = () => {},
      onTaskError = () => {},
    } = options;

    // 存储执行结果和错误
    const results = [];
    const errors = [];

    // 初始化为已完成的Promise，用于启动链
    this.currentPromise = tasks
      .reduce((promiseChain, task, index) => {
        return promiseChain.then(() => {
          // 检查是否已被暂停或终止
          if (!this.canContinue()) {
            return Promise.reject(
              new Error(
                this.isAborted ? "Execution aborted" : "Execution paused"
              )
            );
          }

          // 任务开始回调
          onTaskStart(index, task);

          // 执行当前任务
          return task()
            .then((result) => {
              // 检查是否在任务执行过程中被暂停或终止
              if (!this.canContinue()) {
                return Promise.reject(
                  new Error(
                    this.isAborted ? "Execution aborted" : "Execution paused"
                  )
                );
              }

              // 存储结果
              results[index] = result;
              // 任务完成回调
              onTaskComplete(index, result);
              return result;
            })
            .catch((error) => {
              // 存储错误
              errors[index] = error;
              // 任务错误回调
              onTaskError(index, error);

              // 根据配置决定是否停止执行
              if (stopOnError) {
                // 抛出错误中断后续执行
                throw error;
              }
              // 不停止则继续执行下一个任务
              return null;
            });
        });
      }, Promise.resolve())
      .then(() => ({
        results,
        errors,
        isAborted: this.isAborted,
        isPaused: this.isPaused,
      }))
      .catch((finalError) => ({
        results,
        errors,
        finalError,
        isAborted: this.isAborted,
        isPaused: this.isPaused,
      }));

    return this.currentPromise;
  }
}

// 导出模块
export default SequentialTaskExecutor;
